import sys 
import webbrowser
python = sys.version_info.major
while True:
    if python <=2:
        print("\033[1;31m请使用python3\033[0m")
        webbrowser.open('https://www.python.org/downloads/release/python-3135/')
        exit()
    else:
        print("\033[1;32m欢迎使用pyjd\033[0m")
        print("\033[34;4;7mpyjd版本为：0.1.0\033[0m")
        print("\033[34;4;7m作者：\033[0m\033[32m<李明扬>\033[0m")
        break
# 走马灯动画有bug
def 走马灯():
    """主函数：实现完整的走马灯动画效果"""
    
    import time
    import os
    import random
    import sys
    import math

    # 检查是否在Windows环境
    is_windows = os.name == 'nt'
    if is_windows:
        import ctypes
        kernel32 = ctypes.windll.kernel32
        kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)

    # 颜色定义（增加更多颜色）
    COLORS = [
        '\033[31m',  # 红色
        '\033[32m',  # 绿色
        '\033[33m',  # 黄色
        '\033[34m',  # 蓝色
        '\033[35m',  # 紫色
        '\033[36m',  # 青色
        '\033[37m',  # 白色
        '\033[91m',  # 亮红色
        '\033[92m',  # 亮绿色
        '\033[93m',  # 亮黄色
        '\033[94m',  # 亮蓝色
        '\033[95m',  # 亮紫色
        '\033[96m',  # 亮青色
        '\033[97m',  # 亮白色
        '\033[38;5;208m',  # 橙色
        '\033[38;5;198m',  # 粉色
        '\033[38;5;153m',  # 淡绿色
        '\033[38;5;111m',  # 淡蓝色
    ]

    class TextAnimation:
        """文字动画类"""
        def __init__(self, text, y_position=None):
            self.text = text
            self.max_width, self.max_height = get_terminal_size()
            self.y = y_position or self.max_height // 2  # 垂直居中
            self.start_x = self.max_width  # 从右侧开始
            self.current_x = self.start_x
            self.colors = [random.choice(COLORS) for _ in text]  # 为每个字符分配随机颜色
            self.time = 0
            self.active = True
            self.direction = random.choice([-1, 1])  # 移动方向：-1向左，1向右
            self.speed = random.uniform(0.5, 1.0)  # 移动速度
            self.wave_amplitude = random.uniform(2, 4)  # Q弹幅度
            self.wave_frequency = random.uniform(1.5, 3.0)  # Q弹频率
            self.wave_offset = [random.uniform(0, math.pi * 2) for _ in text]  # 每个字符的相位偏移
            
        def update(self, delta_time):
            """更新动画状态"""
            self.time += delta_time
            
            # 更新水平位置
            self.current_x += self.direction * self.speed
            
            # 边界检查
            if (self.direction < 0 and self.current_x + len(self.text) < 0) or \
               (self.direction > 0 and self.current_x > self.max_width):
                self.active = False
                
            # 持续变换颜色（每个字符独立变换）
            for i in range(len(self.colors)):
                # 每隔一小段时间随机变换颜色
                if random.random() < 0.05:  # 5%的概率变换颜色
                    self.colors[i] = random.choice(COLORS)
        
        def render(self):
            """渲染文字"""
            # 计算实际显示的文本部分
            visible_text = []
            visible_colors = []
            visible_y_offsets = []
            
            for i, char in enumerate(self.text):
                x_pos = int(self.current_x) + i
                if 1 <= x_pos <= self.max_width:
                    visible_text.append(char)
                    visible_colors.append(self.colors[i])
                    
                    # 计算Q弹效果（每个字符有独立的相位）
                    y_offset = int(self.wave_amplitude * math.sin(self.time * self.wave_frequency + self.wave_offset[i]))
                    visible_y_offsets.append(y_offset)
            
            # 打印可见部分
            if visible_text:
                for i, (char, color, y_offset) in enumerate(zip(visible_text, visible_colors, visible_y_offsets)):
                    move_cursor(self.y + y_offset, int(self.current_x) + i)
                    print(color + char + '\033[0m', end="")
    def get_terminal_size():
        """获取终端尺寸"""
        try:
            import shutil
            columns, rows = shutil.get_terminal_size(fallback=(80, 24))
            return columns, rows
        except:
            return 80, 24

    def move_cursor(y, x):
        """移动光标到指定位置"""
        print(f"\033[{y};{x}H", end="")

    def clear_screen():
        """清除屏幕"""
        os.system('cls' if is_windows else 'clear')

    def animate_text_line(text, duration=5.0, fps=30):
        """为整行文字创建Q弹动画效果"""
        max_width, max_height = get_terminal_size()
        
        # 创建文字动画对象
        animation = TextAnimation(text)
        
        # 动画循环
        frame_time = 1.0 / fps
        start_time = time.time()
        last_frame_time = start_time
        
        try:
            while time.time() - start_time < duration and animation.active:
                current_time = time.time()
                delta_time = current_time - last_frame_time
                
                # 控制帧率
                if delta_time < frame_time:
                    time.sleep(frame_time - delta_time)
                    delta_time = frame_time
                    
                last_frame_time = current_time
                
                # 清除屏幕
                clear_screen()
                
                # 更新并渲染文字动画
                animation.update(delta_time)
                animation.render()
                
                # 刷新输出
                sys.stdout.flush()
                
            # 等待动画结束
            while animation.active:
                clear_screen()
                animation.update(0.05)
                animation.render()
                sys.stdout.flush()
                time.sleep(0.05)
                
        except KeyboardInterrupt:
            pass
        
        # 最后清除屏幕
        clear_screen()

    def random_text_animation(text_list, duration=20.0, fps=30):
        """随机选择文本并显示动画效果，总时长20秒"""
        start_time = time.time()
        
        try:
            while time.time() - start_time < duration:
                # 随机选择一个文本
                text = random.choice(text_list)
                
                # 计算剩余时间
                remaining_time = duration - (time.time() - start_time)
                anim_duration = min(random.uniform(3.0, 5.0), remaining_time)
                
                # 执行动画
                animate_text_line(text, duration=anim_duration, fps=fps)
                
                # 随机延迟（如果时间允许）
                delay = random.uniform(0.5, 1.0)
                if time.time() + delay <= start_time + duration:
                    time.sleep(delay)
                    
                # 检查是否超过总运行时间
                if time.time() >= start_time + duration:
                    break
                    
        except KeyboardInterrupt:
            clear_screen()
            print("程序已停止")
        
        clear_screen()
        print("程序运行已达20秒，即将关闭...")
        time.sleep(1)

    # 使用示例
    if __name__ == "__main__":
        # 超长变量名存储文字列表
        AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA = [
            "欢迎使用pyjd！",
            "作者：李明扬",
            "欢迎使用",
        ]
        
        # 运行20秒后自动关闭
        random_text_animation(
            AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA, 
            duration=20.0
        )
def 输出(text):
    print(text)

def 输入():

    return input()
def 随机数(N, M):
    import random
    return random.randint(N, M)
def 随机数列表(N, M, K):
    import random
    列表 = []
    for _ in range(K):
        列表.append(random.randint(N, M))
    return 列表
def 除以 (N,M):
    return N / M
def 乘以(N, M):  # 修复参数定义
    return N * M

def 加(N, M):    # 修复参数定义
    return N + M

def 减(N, M):    # 修复参数定义
    return N - M

def 等于(N, M):  # 修复参数定义
    return N == M

def 不等于(N, M):  # 修复参数定义
    return N != M

def 大于(N, M):  # 修复参数定义
    return N > M

def 小于(N, M):  # 修复参数定义
    return N < M

def 大于等于(N, M):  # 修复参数定义
    return N >= M

def 小于等于(N, M):  # 修复参数定义
    return N <= M

def 取整(N, M):  # 修复参数定义
    return N // M
def 取余(N, M):  # 修复参数定义和括号
    return N % M
def 平方(N):
    return N ** 2

def 立方(N):
    return N ** 3

def 开平方(N):
    import math
    return math.sqrt(N)

def 绝对值(N):
    return abs(N)

def 最大值(N, M):
    return max(N, M)

def 最小值(N, M):
    return min(N, M)

def 输出红色(文本):
    print("\033[31m" + 文本 + "\033[0m")

def 输出绿色(文本):
    print("\033[32m" + 文本 + "\033[0m")

def 输出黄色(文本):
    print("\033[33m" + 文本 + "\033[0m")
def 输出蓝色(文本):
    print("\033[34m" + 文本 + "\033[0m")

def 输出紫色(文本):
    print("\033[35m" + 文本 + "\033[0m")

def 输出青色(文本):
    print("\033[36m" + 文本 + "\033[0m")

def 输出白色(文本):
    print("\033[37m" + 文本 + "\033[0m")
def 输出黑色(文本):
    print("\033[30m" + 文本 + "\033[0m")
def 输出下划线(文本):
    print("\033[4m" + 文本 + "\033[0m")
def 输出粗体(文本):
    print("\033[1m" + 文本 + "\033[0m")
def 输出反色(文本):
    print("\033[7m" + 文本 + "\033[0m")
def 输出闪烁(文本):
    print("\033[5m" + 文本 + "\033[0m")
def 空():
    pass
def 暂停(秒数):
    import time
    time.sleep(秒数)
def 清屏():
    import os
    os.system('cls' if os.name == 'nt' else 'clear')
def 年():
    import time
    return time.localtime().tm_year
    
def 月():
    import time
    return time.localtime().tm_mon
    
def 日():
    import time
    return time.localtime().tm_mday
import os
def 立即关机():
    os.system("shutdown /s /t 0")
def 立即重启():
    os.system("shutdown /r /t 0")
def 立即注销():
    os.system("shutdown /l")
def 延时关机(秒数):
    os.system("shutdown /s /t " + str(秒数))
def 延时重启(秒数):
    os.system("shutdown /r /t " + str(秒数))
def 延时注销(秒数):
    os.system("shutdown /l /t " + str(秒数))
def 取消关机():
    os.system("shutdown /a")
def 取消重启():
    os.system("shutdown /a")
def 取消注销():
    os.system("shutdown /a")
